package com.haozi.ehub.core.util;

import com.haozi.ehub.entity.entities.ReturnData;
import org.apache.commons.lang3.StringUtils;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

/**
 * json格式返回工具类
 * @author ：terry
 * @date ：Created in 2020/6/22 17:36
 * @description：TODO
 * @version: 1.0
 */
@SuppressWarnings(value = "all")
public class ReturnDataUtils {

    /**
     * 返回ReturnData类型成功数据，需要传入封装好的ReturnData类型数据和HttpStatus
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData 封装返回的实体类
     * @param httpStatus 返回状态
     * @return ResponseEntity<ReturnData<T>> 返回的数据类型
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntitySuccess(ReturnData<T> returnData,HttpStatus httpStatus){
        return new ResponseEntity<>(returnData, httpHeaders(), httpStatus);
    }

    /**
     * 返回ReturnData类型成功数据，需要传入封装好的ReturnData类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData 封装返回的实体类
     * @return ResponseEntity<ReturnData<T>> 返回的数据类型
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntitySuccess(ReturnData<T> returnData){
        return new ResponseEntity<>(returnData, httpHeaders(), HttpStatus.OK);
    }

    /**
     * 返回ReturnData类型成功数据，传入任意类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 传入的任意类型数据
     * @return ResponseEntity<ReturnData<T>> 返回的数据类型
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntitySuccess(T t){
        //设置返回头设置返回数据
        ReturnData<T> returnData = new ReturnData<>();
        returnData.setData(t);
        returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        returnData.setStatus(HttpStatus.OK.value());
        returnData.setMsg(HttpStatus.OK.getReasonPhrase());
        return new ResponseEntity<>(returnData, httpHeaders(), HttpStatus.OK);
    }

    /**
     * 返回ReturnData类型成功数据，不需要参数
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @return ResponseEntity<ReturnData<T>> 返回的数据类型
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntitySuccess(){
        //设置返回头设置返回数据
        ReturnData<T> returnData = new ReturnData<>();
        returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        returnData.setStatus(HttpStatus.OK.value());
        returnData.setMsg(HttpStatus.OK.getReasonPhrase());
        return new ResponseEntity<>(returnData, httpHeaders(), HttpStatus.OK);
    }


    /**
     * 返回任意类型成功数据，需要传入任意类型的数据和HttpStatus
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param httpStatus 返回状态
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ResponseEntity<T> responseEntitySuccess(T t,HttpStatus httpStatus){
        return new ResponseEntity<>(t, httpHeaders(), httpStatus);
    }

    /**
     * 返回任意类型成功数据，传入任意类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ResponseEntity<T> responseEntitySuccess2(T t){
        //设置返回头设置返回数据
        return new ResponseEntity<>(t, httpHeaders(), HttpStatus.OK);
    }

    /**
     * 返回任意类型成功数据，传入任意类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ResponseEntity<T> responseEntitySuccess2(){
        //设置返回头设置返回数据
        return new ResponseEntity<>(httpHeaders(), HttpStatus.OK);
    }

    /**
     * 返回成功数据，传入任意类型数据，HTTP状态码和成功信息
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData ReturnData类型数据
     * @param httpStatus HTTP状态码
     * @param msg 成功信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(ReturnData<T> returnData,HttpStatus httpStatus,String msg){
        //设置返回头设置返回数据
        if(returnData != null){
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(httpStatus.getReasonPhrase());
            }
            if(returnData.getStatus() == null){
                returnData.setStatus(httpStatus.value());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(httpStatus.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setMsg(msg);
            returnData.setStatus(httpStatus.value());
            returnData.setCode(Integer.toString(httpStatus.value()));
        }
        return returnData;
    }

    /**
     * 返回成功数据，传入任意类型数据，HTTP状态码和成功信息
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param httpStatus HTTP状态码
     * @param msg 成功信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(T t,HttpStatus httpStatus,String msg){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setMsg(msg);
        returnData.setStatus(httpStatus.value());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回成功数据，传入任意类型数据，HTTP状态码和成功信息
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData ReturnData类型数据
     * @param httpStatus HTTP状态码
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(ReturnData<T> returnData,HttpStatus httpStatus){
        //设置返回头设置返回数据
        if(returnData != null){
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(httpStatus.getReasonPhrase());
            }
            if(returnData.getStatus() == null){
                returnData.setStatus(httpStatus.value());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(httpStatus.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setStatus(httpStatus.value());
            returnData.setMsg(httpStatus.getReasonPhrase());
            returnData.setCode(Integer.toString(httpStatus.value()));
        }
        return returnData;
    }

    /**
     * 返回成功数据，传入任意类型数据，HTTP状态码和成功信息
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param msg 成功信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(ReturnData<T> returnData,String msg){
        //设置返回头设置返回数据
        if(returnData != null){
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(msg);
            }
            if(returnData.getStatus() == null){
                returnData.setStatus(HttpStatus.OK.value());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(HttpStatus.OK.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setMsg(msg);
            returnData.setStatus(HttpStatus.OK.value());
            returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        }
        return returnData;
    }

    /**
     * 返回成功数据，传入任意类型数据，HTTP状态码和成功信息
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param httpStatus HTTP状态码
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(T t,HttpStatus httpStatus){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setStatus(httpStatus.value());
        returnData.setMsg(httpStatus.getReasonPhrase());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回成功数据，传入任意类型数据，HTTP状态码和成功信息
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param msg 成功信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(T t,String msg){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setMsg(msg);
        returnData.setStatus(HttpStatus.OK.value());
        returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        return returnData;
    }

    /**
     * 返回任意类型成功数据，HttpStatus和提示语
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param httpStatus HttpStatus
     * @param msg 提示语
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(HttpStatus httpStatus,String msg){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(null);
        returnData.setMsg(msg);
        returnData.setStatus(httpStatus.value());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回任意类型成功数据，传入任意类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData 返回的数据
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(ReturnData<T> returnData){
        if(returnData != null){
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(HttpStatus.OK.getReasonPhrase());
            }
            if(returnData.getStatus() == null){
                returnData.setStatus(HttpStatus.OK.value());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(HttpStatus.OK.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setStatus(HttpStatus.OK.value());
            returnData.setMsg(HttpStatus.OK.getReasonPhrase());
            returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        }
        return returnData;
    }

    /**
     * 返回任意类型成功数据，传入任意类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(T t){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setStatus(HttpStatus.OK.value());
        returnData.setMsg(HttpStatus.OK.getReasonPhrase());
        returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        return returnData;
    }

    /**
     * 返回任意类型成功数据，传入提示语
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param msg 提示语
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(String msg){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(null);
        returnData.setMsg(msg);
        returnData.setStatus(HttpStatus.OK.value());
        returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        return returnData;
    }

    /**
     * 返回任意类型成功数据，传入HttpStatus
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param httpStatus HttpStatus
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(HttpStatus httpStatus){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setStatus(httpStatus.value());
        returnData.setMsg(httpStatus.getReasonPhrase());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回任意类型成功数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataSuccess(){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setStatus(HttpStatus.OK.value());
        returnData.setMsg(HttpStatus.OK.getReasonPhrase());
        returnData.setCode(Integer.toString(HttpStatus.OK.value()));
        return returnData;
    }

    /**
     * 返回ReturnData类型失败数据，需要传入封装好的ReturnData类型数据和HttpStatus
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:07
     * @param returnData 需要返回的数据
     * @param httpStatus 状态
     * @return  ResponseEntity<ReturnData<T>>
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntityFail(ReturnData<T> returnData,HttpStatus httpStatus){
        return new ResponseEntity<>(returnData, httpHeaders(), httpStatus);
    }

    /**
     * 返回ReturnData类型失败数据，需要传入封装好的ReturnData类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:07
     * @param returnData 需要返回的数据
     * @return  ResponseEntity<ReturnData<T>>
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntityFail(ReturnData<T> returnData){
        return new ResponseEntity<>(returnData, httpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    /**
     * 返回ReturnData类型失败数据,传入任意类型数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:07
     * @param t 传入的任意类型数据
     * @return  ResponseEntity<ReturnData<T>>
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntityFail(T t){
        //设置返回头设置返回数据
        ReturnData<T> returnData = new ReturnData<>();
        returnData.setData(t);
        returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        returnData.setMsg(HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase());
        return new ResponseEntity<>(returnData, httpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    /**
     * 返回ReturnData类型失败数据
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:07
     * @return  ResponseEntity<ReturnData<T>>
     */
    public static <T> ResponseEntity<ReturnData<T>> responseEntityFail(){
        //设置返回头设置返回数据
        ReturnData<T> returnData = new ReturnData<>();
        returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        returnData.setMsg(HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase());
        return new ResponseEntity<>(returnData, httpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    /**
     * 返回任意类型失败数据，需要传入任意类型的数据和HttpStatus
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param httpStatus 返回状态
     * @return ResponseEntity<T> 返回的数据类型
     */
    public static <T> ResponseEntity<T> responseEntityFail(T t,HttpStatus httpStatus){
        return new ResponseEntity<>(t, httpHeaders(), httpStatus);
    }

    /**
     * 返回任意类型失败数据,传入任意类型数据
     * <p>
     * HttpStatus: HttpStatus.INTERNAL_SERVER_ERROR
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:07
     * @param t 任意类型数据
     * @return  ResponseEntity<T> 返回的数据类型
     */
    public static <T> ResponseEntity<T> responseEntityFail2(T t){
        //设置返回头设置返回数据
        return new ResponseEntity<>(t, httpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
    }
    /**
     * 返回任意类型失败数据
     * <p>
     * HttpStatus: HttpStatus.INTERNAL_SERVER_ERROR
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:07
     * @param t 任意类型数据
     * @return  ResponseEntity<T> 返回的数据类型
     */
    public static <T> ResponseEntity<T> responseEntityFail2(){
        //设置返回头设置返回数据
        return new ResponseEntity<>(httpHeaders(), HttpStatus.INTERNAL_SERVER_ERROR);
    }

    /**
     * 返回失败数据，返回失败数据，传入ReturnData类型数据，指定HttpStatus
     *  <p>如果returnData中的msg，status,code没有设置值则设置成传入的参数值</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData ReturnData类型数据
     * @param httpStatus HTTP状态码
     * @param msg 成功信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(ReturnData<T> returnData,HttpStatus httpStatus,String msg){
        //设置返回头设置返回数据
        if(returnData != null){
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(msg);
            }
            if(returnData.getStatus() == null){
                returnData.setStatus(httpStatus.value());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(httpStatus.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setMsg(msg);
            returnData.setStatus(httpStatus.value());
            returnData.setCode(Integer.toString(httpStatus.value()));
        }
        return returnData;
    }

    /**
     * 返回失败数据，传入任意类型数据，指定HttpStatus，传入失败提示信息
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData ReturnData类型数据
     * @param httpStatus HTTP状态码
     * @param msg 成功信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(T t,HttpStatus httpStatus,String msg){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setMsg(msg);
        returnData.setStatus(httpStatus.value());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回失败数据，传入ReturnData类型数据，指定HttpStatus
     * <p>如果returnData中的msg，status,code没有设置值则设置成传入的参数值</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData ReturnData类型数据
     * @param httpStatus HttpStatus
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(ReturnData<T> returnData,HttpStatus httpStatus){
        //设置返回头设置返回数据
        if(returnData != null){
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(httpStatus.getReasonPhrase());
            }
            if(returnData.getStatus() == null){
                returnData.setStatus(httpStatus.value());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(httpStatus.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setMsg(httpStatus.getReasonPhrase());
            returnData.setStatus(httpStatus.value());
            returnData.setCode(Integer.toString(httpStatus.value()));
        }
        return returnData;
    }

    /**
     * 返回失败数据，传入ReturnData类型数据，传入失败提示信息
     * <p>如果没有设置status，则默认设置为HTTP状态码500</p>
     * <p>如果没有设置code，则默认设置为HTTP状态码500</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData ReturnData类型数据
     * @param msg 提示信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(ReturnData<T> returnData,String msg){
        //设置返回头设置返回数据
        if(returnData != null){
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(msg);
            }
            if(returnData.getStatus() == null){
                returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setMsg(msg);
            returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        }
        return returnData;
    }


    /**
     * 返回失败数据，传入任意类型数据，指定HttpStatus
     * <p>默认失败提示为HttpStatus的信息</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param httpStatus HttpStatus
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(T t,HttpStatus httpStatus){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setMsg(httpStatus.getReasonPhrase());
        returnData.setStatus(httpStatus.value());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回失败数据，传入任意类型数据，和失败提示信息
     * <p>HTTP状态码默认设置为500</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @param msg 提示信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(T t,String msg){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setMsg(msg);
        returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        return returnData;
    }

    /**
     * 返回失败数据，传入HttpStatus和提示语
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param httpStatus HttpStatus
     * @param msg 提示信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(HttpStatus httpStatus,String msg){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(null);
        returnData.setMsg(msg);
        returnData.setStatus(httpStatus.value());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回失败数据，ReturnData类型数据
     * <p>如果没有设置数据，则该方法会默认设置HTTP状态码和失败提示</p>
     * <p>如果没有设置数据，则HTTP状态码默认设置为500</p>
     * <p>如果没有设置数据，则失败信息默认为：Internal Server Error</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param returnData ReturnData类型数据
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(ReturnData<T> returnData){
        //设置返回头设置返回数据
        if(returnData != null){
            if(returnData.getStatus() == null){
                returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            }
            if(StringUtils.isEmpty(returnData.getMsg())){
                returnData.setMsg(HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase());
            }
            if(StringUtils.isEmpty(returnData.getCode())){
                returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
            }
        }else{
            returnData = new ReturnData<>();
            returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
            returnData.setMsg(HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase());
            returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        }
        return returnData;
    }

    /**
     * 返回失败数据，传入任意类型数据
     * <p>HTTP状态码默认设置为500</p>
     * <p>失败信息默认为：Internal Server Error</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param t 任意类型数据
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(T t){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(t);
        returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        returnData.setMsg(HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase());
        returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        return returnData;
    }

    /**
     * 返回失败数据，传入任意类型数据
     * <p>HTTP状态码默认设置为500</p>
     * <p>失败信息默认为：Internal Server Error</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param httpStatus HttpStatus
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(HttpStatus httpStatus){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(null);
        returnData.setStatus(httpStatus.value());
        returnData.setMsg(httpStatus.getReasonPhrase());
        returnData.setCode(Integer.toString(httpStatus.value()));
        return returnData;
    }

    /**
     * 返回失败数据，传入失败提示信息
     * <p>HTTP状态码默认设置为500</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @param msg 提示信息
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(String msg){
        ReturnData returnData = new ReturnData();
        returnData.setData(null);
        //设置返回头设置返回数据
        returnData.setMsg(msg);
        returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        return returnData;
    }

    /**
     * 返回失败数据
     * <p>HTTP状态码默认设置为500</p>
     * <p>失败信息默认为：Internal Server Error</p>
     * @author     ： terry
     * @date       ： Created in 2020/6/23 9:01
     * @return ReturnData 返回的数据类型
     */
    public static <T> ReturnData<T> returnDataFail(){
        //设置返回头设置返回数据
        ReturnData returnData = new ReturnData();
        returnData.setData(null);
        returnData.setStatus(HttpStatus.INTERNAL_SERVER_ERROR.value());
        returnData.setMsg(HttpStatus.INTERNAL_SERVER_ERROR.getReasonPhrase());
        returnData.setCode(Integer.toString(HttpStatus.INTERNAL_SERVER_ERROR.value()));
        return returnData;
    }


    /**
     * 设置HTTP头
     * @author     ： terry
     * @date       ： Created in 2020/6/28 15:07
     */
    private static HttpHeaders httpHeaders(){
        HttpHeaders httpHeaders = new HttpHeaders();
        httpHeaders.add(CodeUtils.CONTENT_TYPE, CodeUtils.HTTP_CONTENT_TYPE_JSON);
        return httpHeaders;
    }
}
